Use the new Entry API for HashMaps

diff --git a/src/cargo/core/resolver.rs b/src/cargo/core/resolver.rs
index efc9adb893aea0bcd88ad4194a4c8b4ff8ac4511..f47aa70557c13068723c5e687f289a60f54848cb 100644 (file)
--- a/src/cargo/core/resolver.rs
+++ b/src/cargo/core/resolver.rs
@@ -1,4 +1,5 @@
 use std::collections::{HashMap, HashSet};
+use std::collections::hashmap::{Occupied, Vacant};
 use std::fmt;
 use semver;
 
@@ -323,16 +324,18 @@ fn resolve_deps<'a, R: Registry>(parent: &Summary,
     // Record what list of features is active for this package.
     {
         let pkgid = parent.get_package_id().clone();
-        let features = ctx.resolve.features.find_or_insert(pkgid,
-                                                           HashSet::new());
-        features.extend(used_features.into_iter());
+        match ctx.resolve.features.entry(pkgid) {
+            Occupied(entry) => entry.into_mut(),
+            Vacant(entry) => entry.set(HashSet::new()),
+        }.extend(used_features.into_iter());
     }
 
     // Recursively resolve all dependencies
     for &dep in deps.iter() {
-        if !ctx.resolved.find_or_insert(parent.get_package_id().clone(),
-                                        HashSet::new())
-                        .insert(dep.get_name().to_string()) {
+        if !match ctx.resolved.entry(parent.get_package_id().clone()) {
+            Occupied(entry) => entry.into_mut(),
+            Vacant(entry) => entry.set(HashSet::new()),
+        }.insert(dep.get_name().to_string()) {
             continue
         }
 

diff --git a/src/cargo/ops/cargo_rustc/context.rs b/src/cargo/ops/cargo_rustc/context.rs
index 4b3531cd1d8bef6035de9b3d42f0039122199d22..cba02feff8d54054c0f494e56a37d73114787343 100644 (file)
--- a/src/cargo/ops/cargo_rustc/context.rs
+++ b/src/cargo/ops/cargo_rustc/context.rs
@@ -1,4 +1,5 @@
 use std::collections::{HashMap, HashSet};
+use std::collections::hashmap::{Occupied, Vacant};
 use std::str;
 
 use core::{SourceMap, Package, PackageId, PackageSet, Resolve, Target};
@@ -167,9 +168,10 @@ impl<'a, 'b> Context<'a, 'b> {
 
         let key = (pkg.get_package_id(), target.get_name());
         let req = if target.get_profile().is_plugin() {PlatformPlugin} else {req};
-        self.requirements.insert_or_update_with(key, req, |_, v| {
-            *v = v.combine(req);
-        });
+        match self.requirements.entry(key) {
+            Occupied(mut entry) => { *entry.get_mut() = entry.get().combine(req); }
+            Vacant(entry) => { entry.set(req); }
+        };
 
         for &(pkg, dep) in self.dep_targets(pkg).iter() {
             self.build_requirements(pkg, dep, req, visiting);

diff --git a/src/cargo/ops/cargo_rustc/fingerprint.rs b/src/cargo/ops/cargo_rustc/fingerprint.rs
index 37b14665344ba9938075d3d0ce58b16e36717910..c0ca783c3e269cab39e3ac6c3b9e6532c476536e 100644 (file)
--- a/src/cargo/ops/cargo_rustc/fingerprint.rs
+++ b/src/cargo/ops/cargo_rustc/fingerprint.rs
@@ -1,3 +1,4 @@
+use std::collections::hashmap::{Occupied, Vacant};
 use std::hash::{Hash, Hasher};
 use std::hash::sip::SipHasher;
 use std::io::{fs, File, UserRWX, BufferedReader};
@@ -100,8 +101,10 @@ pub fn prepare_target(cx: &mut Context, pkg: &Package, target: &Target,
                 cx.compilation.binaries.push(dst.clone());
             } else if target.is_lib() {
                 let pkgid = pkg.get_package_id().clone();
-                cx.compilation.libraries.find_or_insert(pkgid, Vec::new())
-                                        .push(root.join(filename));
+                match cx.compilation.libraries.entry(pkgid) {
+                    Occupied(entry) => entry.into_mut(),
+                    Vacant(entry) => entry.set(Vec::new()),
+                }.push(root.join(filename));
             }
         }
     }

diff --git a/src/cargo/ops/cargo_rustc/job_queue.rs b/src/cargo/ops/cargo_rustc/job_queue.rs
index 6372acaf80c08d47b5ee460799130d0e3bf11cc0..6c05c7df7ce38baec829a7ae14f4c6f0aaefc8cf 100644 (file)
--- a/src/cargo/ops/cargo_rustc/job_queue.rs
+++ b/src/cargo/ops/cargo_rustc/job_queue.rs
@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
 use term::color::YELLOW;
 
 use core::{Package, PackageId, Resolve};
@@ -73,8 +74,10 @@ impl<'a, 'b> JobQueue<'a, 'b> {
         // Record the freshness state of this package as dirty if any job is
         // dirty or fresh otherwise
         let fresh = jobs.iter().fold(Fresh, |f1, &(_, f2)| f1.combine(f2));
-        let prev = self.state.find_or_insert(pkg.get_package_id(), fresh);
-        *prev = prev.combine(fresh);
+        match self.state.entry(pkg.get_package_id()) {
+            Occupied(mut entry) => { *entry.get_mut() = entry.get().combine(fresh); }
+            Vacant(entry) => { entry.set(fresh); }
+        };
 
         // Add the package to the dependency graph
         self.queue.enqueue(&self.resolve, Fresh,

diff --git a/src/cargo/util/config.rs b/src/cargo/util/config.rs
index 5610369af2d8e0b659c3b344db9e6835209b1ba3..0cf39c770dcb23b512c3c8a056cb059ba1c83878 100644 (file)
--- a/src/cargo/util/config.rs
+++ b/src/cargo/util/config.rs
@@ -1,6 +1,7 @@
 use std::{fmt, os, mem};
 use std::io::fs::{PathExtensions, File};
 use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
 use std::string;
 
 use serialize::{Encodable,Encoder};
@@ -167,11 +168,10 @@ impl ConfigValue {
             (&Table(ref mut old), Table(ref mut new)) => {
                 let new = mem::replace(new, HashMap::new());
                 for (key, value) in new.into_iter() {
-                    let mut err = Ok(());
-                    old.find_with_or_insert_with(key, value,
-                                                 |_, old, new| err = old.merge(new),
-                                                 |_, new| new);
-                    try!(err);
+                    match old.entry(key) {
+                        Occupied(mut entry) => { try!(entry.get_mut().merge(value)); }
+                        Vacant(entry) => { entry.set(value); }
+                    };
                 }
             }
             (expected, found) => {

diff --git a/src/cargo/util/dependency_queue.rs b/src/cargo/util/dependency_queue.rs
index 8bad655336a638ae979cf51c70aa55a2d453cf01..a07c598ef57e0a6f2f365318e72ca604e2445206 100644 (file)
--- a/src/cargo/util/dependency_queue.rs
+++ b/src/cargo/util/dependency_queue.rs
@@ -5,6 +5,7 @@
 //! it to figure out when a dependency should be built.
 
 use std::collections::{HashMap, HashSet};
+use std::collections::hashmap::{Occupied, Vacant};
 use std::hash::Hash;
 
 pub struct DependencyQueue<K, V> {
@@ -79,7 +80,10 @@ impl<C, K: Dependency<C>, V> DependencyQueue<K, V> {
         let mut my_dependencies = HashSet::new();
         for dep in key.dependencies(cx).into_iter() {
             assert!(my_dependencies.insert(dep.clone()));
-            let rev = self.reverse_dep_map.find_or_insert(dep, HashSet::new());
+            let rev = match self.reverse_dep_map.entry(dep) {
+                Occupied(entry) => entry.into_mut(),
+                Vacant(entry) => entry.set(HashSet::new()),
+            };
             assert!(rev.insert(key.clone()));
         }
         assert!(self.dep_map.insert(key, (my_dependencies, value)));

diff --git a/src/cargo/util/graph.rs b/src/cargo/util/graph.rs
index 63e5a9ec36fea719f2d007d0f65c68e1a44a9a76..b83e4a8e96599b47e72fcaa256e526fd8af114f5 100644 (file)
--- a/src/cargo/util/graph.rs
+++ b/src/cargo/util/graph.rs
@@ -1,7 +1,7 @@
 use std::fmt;
 use std::hash::Hash;
 use std::collections::{HashMap, HashSet};
-use std::collections::hashmap::{Keys, SetItems};
+use std::collections::hashmap::{Keys, Occupied, SetItems, Vacant};
 
 pub struct Graph<N> {
     nodes: HashMap<N, HashSet<N>>
@@ -25,9 +25,10 @@ impl<N: Eq + Hash + Clone> Graph<N> {
     }
 
     pub fn link(&mut self, node: N, child: N) {
-        self.nodes
-            .find_or_insert_with(node, |_| HashSet::new())
-            .insert(child);
+        match self.nodes.entry(node) {
+            Occupied(entry) => entry.into_mut(),
+            Vacant(entry) => entry.set(HashSet::new()),
+        }.insert(child);
     }
 
     pub fn get_nodes(&self) -> &HashMap<N, HashSet<N>> {